import 'dart:async';
import 'dart:developer' as developer;
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import '../../../common/services/rongcloud_service.dart';
import '../../../common/services/business_orchestration_service.dart';
import '../../../common/services/message_storage_service.dart';
import '../../../common/models/chat_message_entity.dart';
import '../../../common/utils/loading_util.dart';
import '../../../common/utils/smart_notification_util.dart';
import '../../../common/mixins/user_profile_mixin.dart';

/// 聊天页面控制器
/// 
/// 🎯 核心功能：
/// - 显示聊天历史记录
/// - 实时接收新消息（响应式更新）
/// - 发送消息（融云IM）
/// - 消息去重
/// - 未读数清除
/// - 智能通知处理
class MessageChatController extends GetxController with UserProfileMixin {
  static const String tag = 'MessageChatController';
  
  // ==================== 路由参数 ====================
  
  /// 好友数据库ID（用于UI显示、业务逻辑）
  int? friendId;
  
  /// 🔥 好友手机号（用于融云IM、本地存储）- 核心标识
  String? friendPhone;
  
  /// 好友名称
  String friendName = '未知用户';
  
  /// 好友头像
  String friendAvatar = '';
  
  // ==================== 响应式数据 ====================
  
  /// 聊天消息列表（响应式）
  final RxList<ChatMessageEntity> messages = <ChatMessageEntity>[].obs;
  
  /// 是否正在加载历史消息
  final RxBool isLoadingHistory = false.obs;
  
  /// 是否还有更多历史消息
  final RxBool hasMoreHistory = true.obs;
  
  // ==================== 分页配置 ====================
  
  /// 每页加载的消息数量
  static const int _pageSize = 50;
  
  /// 当前已加载的消息总数
  int _loadedCount = 0;
  
  /// 所有消息的总数
  int _totalCount = 0;
  
  // ==================== 控制器 ====================
  
  /// 输入框控制器
  final TextEditingController textController = TextEditingController();
  
  /// 滚动控制器
  final ScrollController scrollController = ScrollController();
  
  // ==================== 服务依赖 ====================
  
  RongCloudService get _rongCloud => Get.find<RongCloudService>();
  BusinessOrchestrationService get _orchestration => Get.find<BusinessOrchestrationService>();
  MessageStorageService get _messageStorage => Get.find<MessageStorageService>();
  
  // ==================== 消息监听 ====================
  
  /// 消息流订阅
  StreamSubscription? _messageSubscription;
  
  /// 已接收的消息ID集合（防止重复显示）
  final Set<String> _receivedMessageIds = <String>{};
  
  /// 所有消息（用于分页加载）
  List<ChatMessageEntity> _allMessages = [];
  
  // ==================== 生命周期 ====================
  
  @override
  void onInit() {
    super.onInit();
    developer.log('$tag: ========== 聊天页面初始化 ==========');
    
    // 1. 获取路由参数
    _getArguments();
    
    // 2. 设置滚动监听
    _setupScrollListener();
    
    // 3. 开始监听消息
    _setupMessageListener();
    
    // 4. 🔥 清除该用户的通知（使用手机号）
    if (friendPhone != null && friendPhone!.isNotEmpty) {
      SmartNotificationUtil.instance.clearUserNotifications(friendPhone!);
      developer.log('$tag: ✅ 已清除通知：手机号=$friendPhone');
      
      // 5. 🔥 立即清除未读数（使用手机号）- 重要！进入聊天页面就清除
      clearUnreadCount();
      developer.log('$tag: ✅ 已触发清除未读数：手机号=$friendPhone');
    } else {
      developer.log('$tag: ⚠️ 手机号为空，无法清除通知和未读数');
    }
  }
  
  @override
  void onReady() {
    super.onReady();
    // 加载初始数据
    _initData();
  }
  
  @override
  void onClose() {
    developer.log('$tag: 聊天页面销毁');
    
    // 🔥 页面销毁时再次清除未读数（确保未读数被清除）
    if (friendPhone != null && friendPhone!.isNotEmpty) {
      clearUnreadCount();
      developer.log('$tag: ✅ 页面销毁时清除未读数：手机号=$friendPhone');
    }
    
    // 取消消息监听
    _messageSubscription?.cancel();
    
    // 清理控制器
    textController.dispose();
    scrollController.dispose();
    
    super.onClose();
  }
  
  // ==================== 初始化 ====================
  
  /// 获取传递的参数
  void _getArguments() {
    final args = Get.arguments as Map<String, dynamic>?;
    
    if (args != null) {
      friendId = args['friendId'] as int?;
      friendPhone = args['friendPhone'] as String?;  // 🔥 新增：获取手机号
      friendName = args['friendName'] as String? ?? '未知用户';
      friendAvatar = args['friendAvatar'] as String? ?? '';
      
      developer.log('$tag: 接收到好友信息');
      developer.log('$tag: - 好友数据库ID: $friendId');
      developer.log('$tag: - 🔥 好友手机号: $friendPhone');  // 🔥 新增日志
      developer.log('$tag: - 好友名称: $friendName');
      developer.log('$tag: - 好友头像: $friendAvatar');
    } else {
      developer.log('$tag: ⚠️ 未接收到好友参数');
    }
  }
  
  /// 设置滚动监听（用于加载更多历史消息）
  void _setupScrollListener() {
    scrollController.addListener(() {
      // 当滚动到顶部时，加载更多历史消息
      if (scrollController.position.pixels <= 0 && 
          !isLoadingHistory.value && 
          hasMoreHistory.value) {
        loadMoreHistory();
      }
    });
  }
  
  /// 🔥 设置消息监听器（实时接收新消息）
  void _setupMessageListener() {
    developer.log('$tag: 🔔 开始监听消息流...');
    
    _messageSubscription = _rongCloud.messageStream.listen(
      (message) {
        developer.log('$tag: 📨 收到消息流通知');
        
        // 🔥 检查是否是当前好友的消息（使用手机号匹配）
        final senderId = message.senderUserId;
        if (senderId == null || friendPhone == null || senderId != friendPhone) {
          developer.log('$tag: ⏭️ 消息不属于当前好友，跳过');
          developer.log('$tag:    发送者手机: $senderId');
          developer.log('$tag:    当前好友手机: $friendPhone');
          return;
        }
        
        developer.log('$tag: ✅ 消息属于当前好友，重新加载消息列表');
        developer.log('$tag:    匹配的手机号: $senderId');
        
        // 重新加载消息列表（包含新消息）
        _loadChatHistory();
        
        // 🔥 使用动画滚动到底部（新消息到达）
        _scrollToBottom(animate: true);
      },
      onError: (error) {
        developer.log('$tag: 💥 消息监听异常: $error');
      },
      cancelOnError: false,
    );
    
    developer.log('$tag: ✅ 消息监听器设置完成');
  }
  
  /// 初始化数据
  Future<void> _initData() async {
    // 🔥 验证必要参数（手机号是核心标识）
    if (friendPhone == null || friendPhone!.isEmpty) {
      LoadingUtil.error('好友信息错误');
      developer.log('$tag: ❌ 手机号为空，无法加载聊天记录');
      return;
    }
    
    LoadingUtil.show('加载聊天记录...');
    
    try {
      // 加载聊天历史记录
      await _loadChatHistory();
      
      // 🔥 再次清除该用户的未读数（确保清除成功）
      // 注意：onInit() 中已经清除过一次，这里再清除一次以确保万无一失
      await clearUnreadCount();
      
      LoadingUtil.dismiss();
      
      // 自动滚动到底部
      _scrollToBottom();
      
    } catch (e) {
      LoadingUtil.error('加载聊天记录失败');
      developer.log('$tag: 加载聊天记录失败 - $e');
    }
  }
  
  // ==================== 消息加载 ====================
  
  /// 🔥 加载聊天历史记录（企业级分页加载 - 只加载最近的消息）
  Future<void> _loadChatHistory() async {
    // 🔥 使用手机号加载消息
    if (friendPhone == null || friendPhone!.isEmpty) {
      developer.log('$tag: ⚠️ 手机号为空，无法加载聊天历史');
      return;
    }
    
    try {
      developer.log('$tag: 🔍 加载聊天历史（企业级分页）...');
      developer.log('$tag: 📱 好友手机号: $friendPhone');
      developer.log('$tag: 📄 每页加载: $_pageSize 条');
      
      // 🔥 从融云服务获取所有消息
      final allMessages = await _rongCloud.getUserMessages(friendPhone!);
      
      developer.log('$tag: 📊 总消息数: ${allMessages.length} 条');
      
      // 🔥 消息去重
      final uniqueMessages = <ChatMessageEntity>[];
      final seenIds = <String>{};
      
      for (final msg in allMessages) {
        final msgId = msg.messageId ?? '${msg.timestamp}_${msg.userId}_${msg.content}';
        
        if (!seenIds.contains(msgId)) {
          seenIds.add(msgId);
          uniqueMessages.add(msg);
        }
      }
      
      // 按时间排序（旧消息在前）
      uniqueMessages.sort((a, b) => a.timestamp.compareTo(b.timestamp));
      
      developer.log('$tag: ✅ 去重后总数: ${uniqueMessages.length} 条');
      
      // 🔥 企业级分页：只加载最近的 _pageSize 条消息
      _totalCount = uniqueMessages.length;
      final startIndex = uniqueMessages.length > _pageSize 
          ? uniqueMessages.length - _pageSize 
          : 0;
      final recentMessages = uniqueMessages.sublist(startIndex);
      
      _loadedCount = recentMessages.length;
      
      developer.log('$tag: 📄 本次加载: $_loadedCount 条（最近的消息）');
      developer.log('$tag: 📊 剩余未加载: ${_totalCount - _loadedCount} 条');
      
      // 更新消息列表
      messages.value = recentMessages;
      
      // 更新已接收消息ID集合
      _receivedMessageIds.clear();
      _receivedMessageIds.addAll(seenIds);
      
      // 检查是否有更多历史消息
      hasMoreHistory.value = _loadedCount < _totalCount;
      
      developer.log('$tag: ${hasMoreHistory.value ? "✅ 还有更多历史消息" : "⏹️ 没有更多历史消息"}');
      
      // 🔥 保存所有消息供分页使用
      _allMessages = uniqueMessages;
      
    } catch (e) {
      developer.log('$tag: 💥 加载聊天历史失败: $e');
      messages.value = [];
    }
  }
  
  /// 🔥 加载更多历史消息（企业级分页加载）
  Future<void> loadMoreHistory() async {
    if (isLoadingHistory.value || !hasMoreHistory.value) return;
    
    isLoadingHistory.value = true;
    
    try {
      developer.log('$tag: 📜 加载更多历史消息...');
      developer.log('$tag: 📊 当前已加载: $_loadedCount 条，总数: $_totalCount 条');
      
      // 计算还需要加载多少条
      final remainingCount = _totalCount - _loadedCount;
      final loadCount = remainingCount > _pageSize ? _pageSize : remainingCount;
      
      developer.log('$tag: 📄 本次加载: $loadCount 条');
      
      // 模拟网络延迟
      await Future.delayed(const Duration(milliseconds: 300));
      
      // 从 _allMessages 中获取更早的消息
      final startIndex = _totalCount - _loadedCount - loadCount;
      final endIndex = _totalCount - _loadedCount;
      final olderMessages = _allMessages.sublist(startIndex, endIndex);
      
      developer.log('$tag: 📍 加载区间: [$startIndex, $endIndex)');
      
      // 🔥 保存当前滚动位置（用于恢复）
      final currentScrollOffset = scrollController.hasClients 
          ? scrollController.offset 
          : 0.0;
      final currentItemHeight = scrollController.hasClients 
          ? scrollController.position.maxScrollExtent / messages.length
          : 0.0;
      
      // 将新加载的消息插入到列表前面
      final updatedMessages = [...olderMessages, ...messages];
      messages.value = updatedMessages;
      
      _loadedCount += loadCount;
      
      developer.log('$tag: ✅ 加载完成，当前已加载: $_loadedCount 条');
      developer.log('$tag: 📊 剩余未加载: ${_totalCount - _loadedCount} 条');
      
      // 检查是否还有更多
      hasMoreHistory.value = _loadedCount < _totalCount;
      
      if (!hasMoreHistory.value) {
        developer.log('$tag: ⏹️ 所有历史消息已加载完成');
        // 🔥 不使用 Toast 提示，页面上的 "没有更多消息了" 提示已足够
      }
      
      // 🔥 恢复滚动位置（避免跳到顶部）
      Future.delayed(const Duration(milliseconds: 50), () {
        if (scrollController.hasClients) {
          final newOffset = loadCount * currentItemHeight + currentScrollOffset;
          scrollController.jumpTo(newOffset);
          developer.log('$tag: 📍 恢复滚动位置: $newOffset');
        }
      });
      
    } catch (e) {
      // 🔥 不使用 Toast 提示，页面上会自动显示加载状态
      developer.log('$tag: ❌ 加载更多历史消息失败: $e');
    } finally {
      isLoadingHistory.value = false;
    }
  }
  
  // ==================== 消息发送 ====================
  
  /// 🔥 发送消息
  Future<void> sendMessage() async {
    final content = textController.text.trim();
    
    if (content.isEmpty) {
      LoadingUtil.info('请输入消息内容');
      return;
    }
    
    // 🔥 验证手机号（融云IM必需）
    if (friendPhone == null || friendPhone!.isEmpty) {
      LoadingUtil.error('无法获取好友手机号，无法发送消息');
      developer.log('$tag: ❌ 手机号为空，friendId=$friendId');
      return;
    }
    
    developer.log('$tag: =============== 发送消息 ===============');
    developer.log('$tag: 接收者: $friendName (手机号: $friendPhone)');
    developer.log('$tag: 内容: $content');
    
    // 🔥 乐观更新：立即显示消息（使用手机号作为userId）
    final tempMessage = ChatMessageEntity(
      content: content,
      isMe: true,
      timestamp: DateTime.now().millisecondsSinceEpoch,
      userId: friendPhone!,  // 🔥 使用手机号
      messageId: 'temp_${DateTime.now().millisecondsSinceEpoch}',
      messageType: 'chat',
    );
    
    messages.add(tempMessage);
    textController.clear();
    
    // 🔥 使用动画滚动到底部（发送新消息）
    _scrollToBottom(animate: true);
    
    try {
      // 🔥 调用BusinessOrchestrationService发送消息（使用手机号）
      final success = await _orchestration.sendChatMessage(
        targetId: friendPhone!,  // 🔥 使用手机号
        content: content,
        showLoading: false,
      );
      
      if (success) {
        developer.log('$tag: ✅ 消息发送成功');
        
        // 重新加载消息列表（获取服务器生成的消息ID）
        await _loadChatHistory();
        _scrollToBottom(animate: true);
        
      } else {
        throw Exception('发送失败');
      }
      
    } catch (e) {
      developer.log('$tag: ❌ 消息发送失败: $e');
      LoadingUtil.error('消息发送失败，请重试');
      
      // 移除乐观更新的临时消息
      messages.removeWhere((msg) => msg.messageId == tempMessage.messageId);
      
      // 恢复输入框内容
      textController.text = content;
    }
  }
  
  // ==================== 工具方法 ====================
  
  /// 🔥 滚动到底部（企业级优化：立即跳转，不使用动画）
  /// 
  /// @param animate 是否使用动画（默认 false）
  void _scrollToBottom({bool animate = false}) {
    Future.delayed(const Duration(milliseconds: 100), () {
      if (scrollController.hasClients) {
        if (animate) {
          // 动画滚动（用于发送新消息等场景）
          scrollController.animateTo(
            scrollController.position.maxScrollExtent,
            duration: const Duration(milliseconds: 300),
            curve: Curves.easeOut,
          );
        } else {
          // 🔥 立即跳转（用于初始加载，避免长时间滚动）
          scrollController.jumpTo(scrollController.position.maxScrollExtent);
          developer.log('$tag: 📍 已跳转到底部');
        }
      }
    });
  }
  
  /// 重新加载聊天记录
  Future<void> refreshChatHistory() async {
    await _loadChatHistory();
    _scrollToBottom();
  }
  
  /// 🔥 清除该用户的未读数（直接调用 MessageStorageService）
  Future<void> clearUnreadCount() async {
    // 🔥 使用手机号清除未读数
    if (friendPhone != null && friendPhone!.isNotEmpty) {
      try {
        // 🔥 直接调用 MessageStorageService.clearUserUnreadCount()
        await _messageStorage.clearUserUnreadCount(friendPhone!);
        developer.log('$tag: ✅ 已清除未读数（手机号: $friendPhone）');
        developer.log('$tag: 📊 当前全局未读数: ${_messageStorage.totalUnreadCount.value}');
      } catch (e) {
        developer.log('$tag: ❌ 清除未读数失败: $e');
      }
    } else {
      developer.log('$tag: ⚠️ 手机号为空，无法清除未读数');
    }
  }
}
